home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et-2_2.lha / et2.2 / src / VObject.C < prev    next >
C/C++ Source or Header  |  1990-12-21  |  20KB  |  1,007 lines
  1. //$VObject,VObjectMover,VObjectStretcher,CompositeVObject,VObjectCommand$
  2.  
  3. #include "VObject.h" 
  4. #include "Menu.h"
  5. #include "BlankWin.h"
  6. #include "WindowSystem.h"
  7. #include "String.h"
  8. #include "OrdColl.h"
  9.  
  10. //---- VObject -----------------------------------------------------------------
  11.  
  12. AbstractMetaImpl(VObject, (TP(container), T(id), T(contentRect), 0));
  13.  
  14. VObject::VObject(EvtHandler *next, Rectangle r, int id)
  15. {
  16.     Init(id, r, (View*) next);
  17. }
  18.  
  19. VObject::VObject(Rectangle r, int id)
  20. {
  21.     Init(id, r, 0);
  22. }
  23.  
  24. VObject::VObject(int id)
  25. {
  26.     Init(id, gRect0, 0);
  27. }
  28.  
  29. void VObject::Init(int i, Rectangle r, View *v)
  30. {
  31.     VObject::SetContainer(v);
  32.     id= i;
  33.     contentRect= r;
  34.     SetFlag(eVObjDefault+eVObjOpen);
  35. }
  36.  
  37. char *VObject::AsString()
  38. {
  39.     return "~";
  40. }
  41.  
  42. int VObject::Compare(ObjPtr op)
  43. {
  44.     return StrCmp((byte*)AsString(), (byte*)op->AsString(), -1, sortmap);
  45. }
  46.  
  47. bool VObject::IsEqual(ObjPtr op)
  48. {
  49.     return StrCmp((byte*)AsString(), (byte*)op->AsString(), -1, sortmap) == 0;
  50. }
  51.  
  52. //---- state -------------------------------------------------------------------
  53.  
  54. void VObject::Open(bool mode)
  55. {
  56.     SetFlag(eVObjOpen, mode);
  57. }
  58.  
  59. void VObject::Enable(bool b, bool redraw)
  60. {
  61.     SetFlag(eVObjEnabled, b);
  62.     if (redraw)
  63.     ForceRedraw();
  64. }
  65.  
  66. //---- container ---------------------------------------------------------------
  67.  
  68. void VObject::SetContainer(VObject *v)
  69. {
  70.     container= v;
  71. }
  72.  
  73. VObject *VObject::FindContainerOfClass(Class *cla)
  74. {
  75.     register VObject *vp;
  76.     
  77.     if (cla == Meta(BlankWin))
  78.     vp= this;
  79.     else
  80.     vp= GetContainer();
  81.     
  82.     for (; vp; vp= vp->GetContainer()) {
  83.     if (vp->IsA()->isKindOf(cla))
  84.         return vp;
  85.     }
  86.     return 0;
  87. }
  88.  
  89. Point VObject::ContainerPoint(Point p)
  90. {
  91.     return p;
  92. }
  93.  
  94. Point VObject::GetPortPoint(Point p)
  95. {
  96.     p= ContainerPoint(p);
  97.     if (GetContainer())
  98.     return GetContainer()->GetPortPoint(p);
  99.     return p;
  100. }
  101.  
  102. BlankWin *VObject::GetWindow()
  103. {
  104.     return (BlankWin*) FindContainerOfClass(Meta(BlankWin));
  105. }
  106.  
  107. View *VObject::GetView()
  108. {
  109.     return (View*) FindContainerOfClass(Meta(View));
  110. }
  111.  
  112. Clipper *VObject::Getclipper()
  113. {
  114.     return (Clipper*) FindContainerOfClass(Meta(Clipper));
  115. }
  116.  
  117. void VObject::AddToClipper(class Clipper *clipper)
  118. {
  119.     VObject::SetContainer(clipper);
  120.     CalcExtent();
  121.     SetOrigin(gPoint0);
  122. }
  123.  
  124. void VObject::RemoveFromClipper(class Clipper *clipper)
  125. {
  126.     if (GetContainer() == clipper)
  127.     SetContainer(0);
  128. }
  129.  
  130. Rectangle VObject::GetViewedRect()
  131. {
  132.     return contentRect;
  133. }
  134.  
  135. void VObject::SetFocus(Rectangle r, Point o)
  136. {
  137.     if (GetContainer() && r.Clip(contentRect))
  138.     GetContainer()->SetFocus(r, o);
  139. }
  140.  
  141. //---- tree walking ------------------------------------------------------------
  142.  
  143. VObject *VObject::Detect(BoolFun find, void *arg)
  144. {
  145.     if (find(this, this, arg))
  146.     return this;
  147.     return 0;
  148. }
  149.  
  150. static bool Comp1(Object*, Object *op, void *v)
  151. {
  152.     return (bool) (((VObject*)(op))->GetId() == (int)v);
  153. }
  154.  
  155. static bool Comp2(Object*, Object *op, void *v)
  156. {
  157.     VObject *vop= (VObject*) op;
  158.     Point p= *((Point*)v);
  159.     Point offset= vop->ContainerPoint(gPoint0);
  160.     return (bool) vop->ContainsPoint(p-offset);
  161. }
  162.  
  163. static bool Comp3(Object*, Object *op, void *v)
  164. {
  165.     return op->IsEqual((VObject*)v);
  166. }
  167.  
  168. static bool Comp4(Object*, Object *op, void *v)
  169. {
  170.     return op == (VObject*)v;
  171. }
  172.  
  173. VObject *VObject::FindItem(int id)
  174. {
  175.     if (id != cIdNone)
  176.     return Detect(Comp1, (void*) id);
  177.     return 0;
  178. }
  179.  
  180. VObject *VObject::FindItem(Point p)
  181. {
  182.     return Detect(Comp2, &p);
  183. }
  184.  
  185. VObject *VObject::FindItem(VObject *g)
  186. {
  187.     return Detect(Comp3, g);
  188. }
  189.  
  190. VObject *VObject::FindItemPtr(VObject *g)
  191. {
  192.     return Detect(Comp4, g);
  193. }
  194.  
  195. //---- layout ------------------------------------------------------------------
  196.  
  197. Metric VObject::GetMinSize()
  198. {
  199.     return Metric(contentRect.extent);
  200. }
  201.  
  202. void VObject::CalcExtent()
  203. {
  204.     SetExtent(GetMinSize().Extent());
  205. }
  206.  
  207. int VObject::Base()
  208. { 
  209.     return contentRect.extent.y;
  210. }
  211.  
  212. void VObject::SetOrigin(Point origin)
  213. {
  214.     if (contentRect.origin != origin) {
  215.     contentRect.origin= origin;
  216.     if (TestFlag(eVObjLayoutCntl)) 
  217.         Control(GetId(), cPartOriginChanged, this);
  218.     Object::Send(GetId(), cPartOriginChanged, &origin);
  219.     }
  220. }
  221.  
  222. void VObject::SetExtent(Point extent)
  223. {
  224.     if (contentRect.extent != extent) {
  225.     contentRect.extent= extent;
  226.     if (TestFlag(eVObjLayoutCntl)) 
  227.         Control(GetId(), cPartExtentChanged, this);
  228.     Object::Send(GetId(), cPartExtentChanged, &extent);
  229.     }
  230. }
  231.  
  232. void VObject::SetContentRect(Rectangle r, bool redraw)
  233. {
  234.     if (!redraw && contentRect == r)
  235.     return;
  236.     if (redraw)
  237.     ForceRedraw();
  238.     if (contentRect.extent != r.extent)
  239.     SetExtent(r.extent);
  240.     SetOrigin(r.origin);
  241.     if (redraw)
  242.     ForceRedraw();
  243. }
  244.  
  245. void VObject::Align(Point at, Metric m, VObjAlign ga)
  246. {
  247.     switch (ga & eVObjH) {
  248.     case eVObjHLeft:
  249.     break;
  250.     case eVObjHCenter:
  251.     at.x+= (m.Width() - Width())/2;
  252.     break;
  253.     case eVObjHRight:
  254.     at.x+= m.Width() - Width();
  255.     break;
  256.     }
  257.     switch (ga & eVObjV) {
  258.     case eVObjVBase:
  259.     at.y+= m.Base() - Base();
  260.     break;
  261.     case eVObjVCenter:
  262.     at.y+= (m.Height() - Height())/2;
  263.     break;
  264.     case eVObjVBottom:
  265.     at.y+= m.Height() - Height();
  266.     break;
  267.     }
  268.     SetOrigin(at);
  269. }
  270.  
  271. void VObject::Move(Point delta, bool redraw)
  272. {
  273.     if (delta == gPoint0)
  274.     return;
  275.     if (redraw)
  276.     ForceRedraw();
  277.     SetOrigin(GetOrigin()+delta);
  278.     if (redraw) {
  279.     ForceRedraw();
  280.     Changed();
  281.     }
  282. }
  283.  
  284. //---- resizing ----------------------------------------------------------------
  285.  
  286. Command *VObject::GetMover()
  287. {
  288.     VObject *v= GetView();
  289.     if (v)
  290.     return new VObjectMover(this, v->contentRect);
  291.     return new VObjectMover(this);
  292. }
  293.  
  294. Command *VObject::GetStretcher()
  295. {
  296.     VObject *v= GetView();
  297.     if (v)
  298.     return new VObjectStretcher(this, v->contentRect);
  299.     return new VObjectStretcher(this);
  300. }
  301.  
  302. bool VObject::ContainsPoint(Point p)
  303. {
  304.     return contentRect.ContainsPoint(p);
  305. }
  306.  
  307. //---- drawing -----------------------------------------------------------------
  308.  
  309. static VObject *aetsch= 0;
  310.  
  311. void VObject::DrawAll(Rectangle r, bool highlight)
  312. {
  313.     if (IsOpen() && r.Clip(contentRect))
  314.     DrawInner(r, (bool) (highlight || aetsch == this));
  315. }
  316.  
  317. void VObject::DrawInner(Rectangle r, bool highlight)
  318. {
  319.     if (!GrHasColor())
  320.     Draw(r);
  321.     if (highlight && ! gPrinting) {
  322.     GrSetPattern(gHighlightColor);
  323.     GrSetPenPattern(gHighlightColor);
  324.     DrawHighlight(r);
  325.     GrSetPattern(ePatBlack);
  326.     GrSetPenNormal();
  327.     }
  328.     if (GrHasColor())
  329.     Draw(r);
  330. }
  331.  
  332. void VObject::Draw(Rectangle r)
  333. {
  334. }
  335.  
  336. void VObject::DrawHighlight(Rectangle r)
  337. {
  338.     GrFillRect(r);
  339. }
  340.  
  341. void VObject::Highlight(HighlightState hst)
  342. {
  343.     if (hst)
  344.     aetsch= this;
  345.     ForceRedraw();
  346.     UpdateEvent();
  347.     aetsch= 0;
  348. }
  349.  
  350. void VObject::Outline2(Point p1, Point p2)
  351. {
  352.     GrStrokeRect(NormRect(p1, p2));
  353. }
  354.  
  355. void VObject::OutlineRect(Rectangle r)
  356. {
  357.     Outline2(r.NW(), r.SE());
  358. }
  359.  
  360. void VObject::Outline(Point delta)
  361. {
  362.     OutlineRect(contentRect+delta);
  363. }
  364.  
  365. //---- invalidation and focusing -----------------------------------------------
  366.  
  367. void VObject::InvalidateRect(Rectangle r)
  368. {
  369.     if (r.Clip(contentRect) && IsOpen() && GetContainer())
  370.     GetContainer()->InvalidateViewRect(r);
  371. }
  372.  
  373. void VObject::InvalidateViewRect(Rectangle r)
  374. {
  375.     r.origin= ContainerPoint(r.origin);
  376.     InvalidateRect(r);
  377. }
  378.  
  379. void VObject::ForceRedraw()
  380. { 
  381.     InvalidateRect(contentRect); 
  382. }
  383.  
  384. void VObject::UpdateEvent()
  385. {
  386.     if (IsOpen() && GetContainer())
  387.     GetContainer()->UpdateEvent();
  388. }
  389.  
  390. GrCursor VObject::GetCursor(Point lp)
  391. {
  392.     if (GetContainer())
  393.     return GetContainer()->GetCursor(ContainerPoint(lp));
  394.     return eCrsBoldArrow;
  395. }
  396.  
  397. //---- input/output ------------------------------------------------------------
  398.  
  399. ostream& VObject::PrintOn(ostream &s)
  400. {
  401.     EvtHandler::PrintOn(s);
  402.     return s << id SP << contentRect SP;
  403. }
  404.  
  405. istream& VObject::ReadFrom(istream &s)
  406. {
  407.     EvtHandler::ReadFrom(s);
  408.     return s >> id >> contentRect;
  409. }
  410.  
  411. //---- input handling ----------------------------------------------------------
  412.  
  413. EvtHandler *VObject::GetNextHandler()
  414. {
  415.     return GetContainer();
  416. }
  417.  
  418. void VObject::DoOnItem(int, VObject*, Point)
  419. {
  420. }
  421.  
  422. Command *VObject::Input(Point lp, Token t, Clipper *vf)
  423. {
  424.     if (ContainsPoint(lp) /* && IsOpen() */) {
  425.     if (Enabled())
  426.         return DispatchEvents(lp, t, vf);
  427.     return gNoChanges;
  428.     }
  429.     return 0;     
  430. }
  431.  
  432. Command *VObject::DispatchEvents(Point lp, Token t, Clipper *vf)
  433. {
  434.     extern int Clicks;
  435.     register Command *currCmd= gNoChanges;
  436.     
  437.     if (t.IsMouseButton() || t.Code == eEvtEnter || t.Code == eEvtExit 
  438.             || t.Code == eEvtLocMove || t.Code == eEvtLocStill)
  439.     GrSetCursor(GetCursor(lp));
  440.  
  441.     switch (t.Code) {
  442.     case eEvtRightButton:
  443.     if (!(t.Flags & eFlgButDown))
  444.         currCmd= DoRightButtonDownCommand(lp, t, Clicks, vf);
  445.     break;
  446.     case eEvtMiddleButton:
  447.     case eEvtLeftButton:
  448.     if (!(t.Flags & eFlgButDown)) {
  449.         if (t.Code == eEvtLeftButton) {
  450.         if (t.Flags == (eFlgShiftKey|eFlgCntlKey|eFlgMetaKey))
  451.             Inspect();
  452.         else
  453.             currCmd= DoLeftButtonDownCommand(lp, t, Clicks);
  454.         } else
  455.         currCmd= DoMiddleButtonDownCommand(lp, t, Clicks);
  456.         if (currCmd && currCmd != gNoChanges && vf)
  457.         currCmd= vf->TrackInContent(lp, t, currCmd);
  458.     }
  459.     break;
  460.     default:
  461.     if (t.IsKey())
  462.         currCmd= DoKeyCommand(t.Code, lp, t);
  463.     else if (t.IsFunctionKey()) 
  464.         currCmd= DoFunctionKeyCommand(t.FunctionCode(), lp, t);
  465.     else if (t.IsCursorKey())
  466.         currCmd= DoCursorKeyCommand(t.CursorDir(), lp, t);
  467.     else if (t.Code == eEvtIdle)
  468.         currCmd= DoIdleCommand();
  469.     else
  470.         currCmd= DoOtherEventCommand(lp, t);
  471.     break;
  472.     }
  473.     return currCmd;
  474. }
  475.  
  476. Command *VObject::DoKeyCommand(int ch, Point lp, Token t)
  477. {
  478.     if (GetContainer())
  479.     return GetContainer()->DoKeyCommand(ch, ContainerPoint(lp), t);
  480.     return gNoChanges;
  481. }
  482.  
  483. Command *VObject::DoCursorKeyCommand(EvtCursorDir d, Point p, Token t)
  484. {
  485.     if (GetContainer())
  486.     return GetContainer()->DoCursorKeyCommand(d, ContainerPoint(p), t);
  487.     return gNoChanges;
  488. }
  489.  
  490. Command *VObject::DoFunctionKeyCommand(int pfk, Point lp, Token t)
  491. {
  492.     int code= -1;
  493.     
  494.     switch (t.FunctionCode()) {
  495.     case 3:
  496.     code= cUNDO;
  497.     break;
  498.     case 5:
  499.     code= cCOPY;
  500.     break;
  501.     case 4:
  502.     code= cTOP;
  503.     break;
  504.     case 7:
  505.     code= cPASTE;
  506.     break;
  507.     case 9:
  508.     code= cCUT;
  509.     break;
  510.     case 8:
  511.     code= cFIND;
  512.     break;
  513.     case 6:
  514.     code= cOPEN;
  515.     break;
  516.     }
  517.     if (code > 0)
  518.     return DoMenuCommand(code);
  519.     if (GetContainer())
  520.     return GetContainer()->DoFunctionKeyCommand(pfk, ContainerPoint(lp), t);
  521.     return gNoChanges;
  522. }
  523.  
  524. Command *VObject::DoMiddleButtonDownCommand(Point p, Token t, int clicks)
  525. {
  526.     if (GetContainer())
  527.     return GetContainer()->DoMiddleButtonDownCommand(ContainerPoint(p), t, clicks);
  528.     return gNoChanges;
  529. }
  530.  
  531. Command *VObject::DoLeftButtonDownCommand(Point p, Token t, int clicks)
  532. {
  533.     if (GetContainer())
  534.     return GetContainer()->DoLeftButtonDownCommand(ContainerPoint(p), t, clicks);
  535.     return gNoChanges;
  536. }
  537.  
  538. Command *VObject::DoOtherEventCommand(Point p, Token t)
  539. {
  540.     if (GetContainer())
  541.     return GetContainer()->DoOtherEventCommand(ContainerPoint(p), t);
  542.     return gNoChanges;
  543. }
  544.  
  545. Command *VObject::DoRightButtonDownCommand(Point lp, Token, int, Clipper *vf)
  546. {
  547.     Menu *menu;
  548.  
  549.     if (vf && (menu= GetMenu())) {
  550.     int cmdno;
  551.  
  552.     if (menu->IsNew())
  553.         DoCreateMenu(menu);                     // append menu items
  554.     menu->DisableAll();
  555.     DoSetupMenu(menu);                          // enable some menu items
  556.     if ((cmdno= menu->Show(lp, vf)) >= 0) {     // show menu in window
  557.         vf->Focus();
  558.         return DoMenuCommand(cmdno);
  559.     }
  560.     }
  561.     return gNoChanges;
  562. }
  563.  
  564. Command *VObject::TrackInContent(Point, Token, Command *currCmd)
  565. {
  566.     return currCmd;
  567. }
  568.  
  569. //---- misc --------------------------------------------------------------------
  570.  
  571. void VObject::Print()
  572. {
  573.     extern int ShowPrintDialog(VObject*);
  574.     
  575.     ShowPrintDialog(this);
  576. }
  577.  
  578. //---- VObjectCommand ----------------------------------------------------------
  579.  
  580. VObjectCommand::VObjectCommand(VObject *g) : Command(cIdNone)
  581. {
  582.     vop= g;
  583.     SetFlag(eCmdNoReplFeedback);
  584. }
  585.  
  586. void VObjectCommand::Init(VObject *g, Rectangle cr, Point gr, GrCursor cd, int hy)
  587. {
  588.     vop= g;
  589.     constrainRect= cr;
  590.     grid= gr;
  591.     newcursor= cd;
  592.     firstmove= FALSE;
  593.     hysterese= hy;
  594.     oldRect= newRect= vop->ContentRect();  
  595. }
  596.  
  597. Command *VObjectCommand::TrackMouse(TrackPhase atp, Point ap, Point, Point np)
  598. {
  599.     switch (atp) {
  600.     case eTrackPress:
  601.     oldcursor= GrGetCursor();
  602.     break;
  603.  
  604.     case eTrackRelease:
  605.     GrSetCursor(oldcursor);
  606.     
  607.     if (firstmove) {
  608.         if (vop->GetView() && !TestFlag(eCmdFullScreen))     
  609.         vop->SetContentRect(oldRect, FALSE);
  610.  
  611.         if (TestFlag(eCmdCanUndo))
  612.         break;
  613.         DoIt();
  614.     }
  615.     return gNoChanges;
  616.  
  617.     case eTrackMove:
  618.     delta= np - ap;
  619.     if (abs(delta.x) > hysterese || abs(delta.y) > hysterese) {
  620.         firstmove= TRUE;
  621.         GrSetCursor(newcursor);
  622.     }
  623.     break;
  624.     }
  625.     return this;
  626. }
  627.  
  628. void VObjectCommand::TrackConstrain(Point ap, Point, Point *np)
  629. {
  630.     Rectangle r= oldRect;
  631.  
  632.     r.origin+= *np-ap;
  633.     *np+= r.AmountToTranslateWithin(constrainRect);
  634.     if (grid >= 1)
  635.     *np= (*np/grid) * grid;     // align to grid
  636. }
  637.  
  638. void VObjectCommand::TrackFeedback(Point, Point, bool on)
  639. {
  640.     if (firstmove) {
  641.     if (port->penink != ePatXor) {
  642.         if (on)
  643.         vop->SetContentRect(newRect, TRUE);
  644.     } else
  645.         vop->Outline2(newRect.NW(), newRect.SE());
  646.     }
  647. }
  648.  
  649. void VObjectCommand::DoIt()
  650. {
  651.     vop->SetContentRect(newRect, !TestFlag(eCmdFullScreen));
  652. }
  653.  
  654. void VObjectCommand::UndoIt()
  655. {
  656.     vop->SetContentRect(oldRect, !TestFlag(eCmdFullScreen));
  657. }
  658.  
  659. //---- VObjectMover ------------------------------------------------------------
  660.  
  661. VObjectMover::VObjectMover(VObject *g) : VObjectCommand(g)
  662. {
  663.     Init(g, gRect0, gPoint1, eCrsMoveHand, 2);
  664. }
  665.  
  666. VObjectMover::VObjectMover(VObject *g, Rectangle cr) : VObjectCommand(g)
  667. {
  668.     Init(g, cr, gPoint1, eCrsMoveHand, 2);
  669. }
  670.  
  671. VObjectMover::VObjectMover(VObject *g, Rectangle cr, Point gr, GrCursor cd,
  672.                             int hy) : VObjectCommand(g)
  673. {
  674.     Init(g, cr, gr, cd, hy);
  675. }
  676.  
  677. void VObjectMover::Init(VObject *g, Rectangle cr, Point gr, GrCursor cd, int hy)
  678. {
  679.     SetName("move");
  680.     VObjectCommand::Init(g, cr, gr, cd, hy);
  681. }
  682.  
  683. Command *VObjectMover::TrackMouse(TrackPhase atp, Point ap, Point pp, Point np)
  684. {
  685.     Command *cmd= VObjectCommand::TrackMouse(atp, ap, pp, np);
  686.     switch (atp) {
  687.     case eTrackMove:
  688.     newRect= oldRect;
  689.     newRect.origin+= delta;
  690.     return this;
  691.     case eTrackRelease:
  692.     if (newRect == oldRect)
  693.         cmd= gNoChanges;
  694.     break;
  695.     }
  696.     return cmd;
  697. }
  698.  
  699. //---- VObjectStretcher --------------------------------------------------------
  700.  
  701. VObjectStretcher::VObjectStretcher(VObject *g) : VObjectCommand(g)
  702. {
  703.     Init(g, gRect0, gPoint1, eCrsMoveStretch, 2, g->GetMinSize());
  704. }
  705.  
  706. VObjectStretcher::VObjectStretcher(VObject *g, Rectangle cr) : VObjectCommand(g)
  707. {
  708.     Init(g, cr, gPoint1, eCrsMoveStretch, 2, g->GetMinSize());
  709. }
  710.  
  711. VObjectStretcher::VObjectStretcher(VObject *g, Rectangle cr, Point ms) : VObjectCommand(g)
  712. {
  713.     Init(g, cr, ms, eCrsMoveStretch, 2, g->GetMinSize());
  714. }
  715.  
  716. VObjectStretcher::VObjectStretcher(VObject *g, Rectangle cr, Point ms, Point gr,
  717.                     GrCursor cd, int hy) : VObjectCommand(g)
  718. {
  719.     Init(g, cr,  gr, cd, hy, ms);
  720. }
  721.  
  722. void VObjectStretcher::Init(VObject *g, Rectangle cr, Point gr,
  723.                         GrCursor cd, int hy, Point ms)
  724. {
  725.     SetName("resize");
  726.     VObjectCommand::Init(g, cr, gr, cd, hy);
  727.     minSize= ms;
  728. }
  729.  
  730. void VObjectStretcher::TrackConstrain(Point ap, Point, Point *np)
  731. {  
  732.     switch (corner) {
  733.     case 0: case 4:
  734.     np->x= ap.x;
  735.     break;
  736.     case 2: case 6:
  737.     np->y= ap.y;
  738.     break;
  739.     }
  740. }
  741.  
  742. Command *VObjectStretcher::TrackMouse(TrackPhase atp, Point ap, Point pp, Point np)
  743. {
  744.     Point p1, p2;
  745.  
  746.     switch (atp) {
  747.     case eTrackPress:
  748.     VObjectCommand::TrackMouse(atp, ap, pp, np);
  749.     corner= oldRect.PointToCorner(ap);
  750.     break;
  751.  
  752.     case eTrackMove:
  753.     VObjectCommand::TrackMouse(atp, ap, pp, np);
  754.     p1= oldRect.NW();
  755.     p2= oldRect.SE();
  756.  
  757.     switch (corner) {
  758.     case 0: case 6: case 7:
  759.         p1+= delta;
  760.         break;
  761.     case 1:
  762.         p2.x+= delta.x;
  763.         p1.y+= delta.y;
  764.         break;
  765.     case 5:
  766.         p1.x+= delta.x;
  767.         p2.y+= delta.y;
  768.         break;
  769.     default: // case 2: case 3: case 4:
  770.         p2+= delta;
  771.         break;
  772.     }
  773.     newRect= NormRect(p1, p2);
  774.     newRect.extent= Max(newRect.extent, minSize);
  775.     break;
  776.  
  777.     case eTrackRelease:
  778.     return VObjectCommand::TrackMouse(atp, ap, pp, np);
  779.     }
  780.     return this;
  781. }
  782.  
  783. //---- CompositeVObject --------------------------------------------------------------
  784.  
  785. AbstractMetaImpl(CompositeVObject, (TB(modified), TP(list), 0));
  786.  
  787. CompositeVObject::CompositeVObject(int id, Collection *cp) : VObject(id)
  788. {
  789.     list= cp;
  790.     if (list == 0)
  791.     list= new OrdCollection;
  792.     list->ForEach(VObject,SetContainer)(this);
  793.     modified= TRUE;
  794. }
  795.  
  796. CompositeVObject::CompositeVObject(int va_(id), ...) : VObject(va_(id))
  797. {
  798.     va_list ap;
  799.     va_start(ap,va_(id));
  800.     list= new OrdCollection;
  801.     SetItems(ap);
  802.     modified= TRUE;
  803.     va_end(ap);
  804. }
  805.  
  806. CompositeVObject::CompositeVObject(int id, va_list ap) : VObject(id)
  807. {
  808.     list= new OrdCollection;
  809.     SetItems(ap);
  810.     modified= TRUE;
  811. }
  812.  
  813. CompositeVObject::~CompositeVObject()
  814. {
  815.     SafeDelete(list);
  816. }
  817.  
  818. void CompositeVObject::FreeAll()
  819. {
  820.     if (list) {
  821.     list->FreeAll();
  822.     SafeDelete(list);
  823.     }    
  824. }
  825.  
  826. Collection *CompositeVObject::GetList()
  827. {
  828.     return list;
  829. }
  830.  
  831. int CompositeVObject::Size()
  832. {
  833.     if (list) 
  834.     return list->Size();
  835.     return 0;
  836. }
  837.  
  838. void CompositeVObject::Add(VObject *vop)
  839. {
  840.     if (vop) {
  841.     if (list == 0)
  842.         list= new OrdCollection;
  843.     list->Add(vop);
  844.     vop->SetContainer(this);
  845.     SetModified();
  846.     }
  847. }
  848.  
  849. VObject *CompositeVObject::Remove(VObject* vop)
  850. {
  851.     if (list) {
  852.     SetModified();
  853.     return (VObject*) list->Remove(vop);
  854.     }
  855.     return 0;
  856. }
  857.  
  858. VObject *CompositeVObject::SetAt(int at, VObject *vop)
  859. {
  860.     VObject *old= 0;
  861.     
  862.     if (vop) {
  863.     if (list->Size() > 0)
  864.         old= (VObject*) list->RemovePtr(At(at));
  865.     ((OrdCollection*)list)->AddAt(at, vop);
  866.     vop->SetContainer(this);
  867.     SetExtent(GetExtent());
  868.     SetOrigin(GetOrigin());
  869.     }
  870.     return old;
  871. }
  872.  
  873. Iterator *CompositeVObject::MakeIterator()
  874. {
  875.     if (list)
  876.     return list->MakeIterator();
  877.     return 0;
  878. }
  879.  
  880. void CompositeVObject::Open(bool mode)
  881. {
  882.     VObject::Open(mode);
  883.     if (list) {
  884.     list->ForEach(CompositeVObject,Open)(mode);
  885.     }
  886. }
  887.  
  888. void CompositeVObject::DoObserve(int, int, void*, Object *op)
  889. {
  890.     if (op == list)
  891.     SetModified();
  892. }
  893.  
  894. void CompositeVObject::SendDown(int id, int part, void *val)
  895. {
  896.     list->ForEach(VObject,SendDown)(id, part, val);
  897. }
  898.  
  899. void CompositeVObject::SetItems(va_list ap)
  900. {
  901.     list->AddVector(ap);
  902.     {
  903.     list->ForEach(VObject,SetContainer)(this);
  904.     }
  905. }
  906.  
  907. void CompositeVObject::SetContainer(VObject *v)
  908. {
  909.     VObject::SetContainer(v);
  910.     list->ForEach(VObject,SetContainer)(this);
  911. }
  912.  
  913. void CompositeVObject::Enable(bool b, bool redraw)
  914. {
  915.     VObject::Enable(b);
  916.     list->ForEach(VObject,Enable)(b, redraw);
  917. }
  918.  
  919. void CompositeVObject::Draw(Rectangle r)
  920. {
  921.     list->ForEach(VObject,DrawAll)(r, FALSE);
  922. }
  923.  
  924. void CompositeVObject::Outline2(Point p1, Point p2)
  925. {
  926.     list->ForEach(VObject,Outline2)(p1, p2);
  927. }
  928.  
  929. VObject *CompositeVObject::Detect(BoolFun find, void *arg)
  930. {
  931.     VObject *g1, *g2;
  932.     Iter next(list);
  933.  
  934.     while (g1= (VObject*) next())
  935.     if (g2= g1->Detect(find, arg))
  936.         return g2;
  937.     if (VObject::Detect(find, arg))
  938.     return (VObject*) this;
  939.     return 0;
  940. }
  941.  
  942. Command *CompositeVObject::DispatchEvents(Point lp, Token t, Clipper *vf)
  943. {
  944.     Command *cmd;
  945.     RevIter next((SeqCollection*)list);
  946.     VObject *dip;
  947.  
  948.     while (dip= (VObject*) next()) 
  949.     if (cmd= dip->Input(lp, t, vf))
  950.         return cmd;
  951.     return VObject::DispatchEvents(lp, t, vf);
  952. }
  953.  
  954. void CompositeVObject::SetOrigin(Point at)
  955. {
  956.     VObject::SetOrigin(at);
  957.     list->ForEach(VObject,SetOrigin)(at);
  958. }
  959.  
  960. void CompositeVObject::SetExtent(Point e)
  961. {
  962.     VObject::SetExtent(e);
  963.     list->ForEach(VObject,CalcExtent)();
  964. }
  965.  
  966. Metric CompositeVObject::GetMinSize()
  967. {
  968.     Metric m;
  969.     Iter next(list);
  970.     VObject *dip;
  971.  
  972.     while (dip= (VObject*) next())
  973.     m.Merge(dip->GetMinSize());
  974.     return m;
  975. }
  976.  
  977. int CompositeVObject::Base()
  978. {
  979.     return GetMinSize().base;
  980. }
  981.  
  982. ostream& CompositeVObject::PrintOn(ostream &s)
  983. {
  984.     VObject::PrintOn(s);
  985.     return s << list SP;
  986. }
  987.  
  988. istream& CompositeVObject::ReadFrom(istream &s)
  989. {
  990.     VObject::ReadFrom(s);
  991.     s >> list;
  992.     SetModified();
  993.     return s;
  994. }
  995.  
  996. void CompositeVObject::Parts(Collection* col)
  997. {
  998.     VObject::Parts(col);
  999.     col->Add(list);
  1000. }
  1001.  
  1002. void CompositeVObject::InspectorId(char *buf, int bufSize)
  1003. {
  1004.     VObject::InspectorId(buf, bufSize);
  1005. }
  1006.  
  1007.